home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / formats / iff / newiff.lzh / NewIFF / NewIFF.lzh / newiff / iffp / ilbm.h < prev    next >
C/C++ Source or Header  |  1992-05-18  |  10KB  |  274 lines
  1. /* 
  2.  *
  3.  * ilbm.h:    Definitions for IFFParse ILBM reader.
  4.  *
  5.  * 5/92
  6.  */
  7.  
  8. #ifndef IFFP_ILBM_H
  9. #define IFFP_ILBM_H
  10.  
  11. #ifndef IFFP_IFF_H
  12. #include "iffp/iff.h"
  13. #endif
  14.  
  15. #ifndef INTUITION_INTUITION_H
  16. #include <intuition/intuition.h>
  17. #endif
  18. #ifndef GRAPHICS_VIDEOCONTROL_H
  19. #include <graphics/videocontrol.h>
  20. #endif
  21.  
  22. #ifndef NO_PROTOS
  23. #include <clib/graphics_protos.h>
  24. #include <clib/intuition_protos.h>
  25. #include <clib/alib_protos.h>
  26. #endif
  27. #ifndef NO_SAS_PRAGMAS
  28. extern struct Library *IntuitionBase;
  29. #include <pragmas/intuition_pragmas.h>
  30. extern struct Library *GfxBase;
  31. #include <pragmas/graphics_pragmas.h>
  32. #endif
  33.  
  34. /*  IFF types we may encounter  */
  35. #define    ID_ILBM        MAKE_ID('I','L','B','M')
  36.  
  37. /* ILBM Chunk ID's we may encounter
  38.  * (see iffp/iff.h for some other generic chunks)
  39.  */
  40. #define    ID_BMHD        MAKE_ID('B','M','H','D')
  41. #define    ID_CMAP        MAKE_ID('C','M','A','P')
  42. #define    ID_CRNG        MAKE_ID('C','R','N','G')
  43. #define    ID_CCRT        MAKE_ID('C','C','R','T')
  44. #define    ID_GRAB        MAKE_ID('G','R','A','B')
  45. #define    ID_SPRT        MAKE_ID('S','P','R','T')
  46. #define    ID_DEST        MAKE_ID('D','E','S','T')
  47. #define    ID_CAMG        MAKE_ID('C','A','M','G')
  48.  
  49. /* Use this constant instead of sizeof(ColorRegister). */
  50. #define sizeofColorRegister  3
  51.  
  52. typedef WORD Color4;   /* Amiga RAM version of a color-register,
  53.           * with 4 bits each RGB in low 12 bits.*/
  54.  
  55. /* Maximum number of bitplanes storable in BitMap structure */
  56. #define MAXAMDEPTH 8
  57.  
  58. /* Use ViewPort->ColorMap.Count instead 
  59. #define MAXAMCOLORREG 32
  60. */
  61.  
  62. /* Maximum planes we can save */
  63. #define MAXSAVEDEPTH 24
  64.  
  65. /* Convert image width to even number of BytesPerRow for ILBM save.
  66.  * Do NOT use this macro to determine the actual number of bytes per row
  67.  * in an Amiga BitMap scan line.  For that, use BitMap->BytesPerRow.
  68.  */
  69. #define    BytesPerRow(w)    ((w) + 15 >> 4 << 1)
  70. #define BitsPerRow(w)    ((w) + 15 >> 4 << 4)
  71.  
  72. /* Flags that should be masked out of old 16-bit CAMG before save or use.
  73.  * Note that 32-bit mode id (non-zero high word) bits should not be twiddled
  74.  */
  75. #define BADFLAGS  (SPRITES|VP_HIDE|GENLOCK_AUDIO|GENLOCK_VIDEO)
  76. #define OLDCAMGMASK  (~BADFLAGS)
  77.  
  78.  
  79. /*  Masking techniques  */
  80. #define    mskNone            0
  81. #define    mskHasMask        1
  82. #define    mskHasTransparentColor    2
  83. #define    mskLasso        3
  84.  
  85. /*  Compression techniques  */
  86. #define    cmpNone            0
  87. #define    cmpByteRun1        1
  88.  
  89. #define RowBytes(w)    ((((w) + 15) >> 4) << 1)
  90.  
  91. /* ---------- BitMapHeader ---------------------------------------------*/
  92. /*  Required Bitmap header (BMHD) structure describes an ILBM */
  93. typedef struct {
  94.     UWORD    w, h;        /* Width, height in pixels */
  95.     WORD    x, y;        /* x, y position for this bitmap  */
  96.     UBYTE    nPlanes;    /* # of planes (not including mask) */
  97.     UBYTE    masking;    /* a masking technique listed above */
  98.     UBYTE    compression;    /* cmpNone or cmpByteRun1 */
  99.     UBYTE    reserved1;    /* must be zero for now */
  100.     UWORD    transparentColor;
  101.     UBYTE    xAspect, yAspect;
  102.     WORD    pageWidth, pageHeight;
  103. } BitMapHeader;
  104.  
  105. /* ---------- ColorRegister --------------------------------------------*/
  106. /* A CMAP chunk is a packed array of ColorRegisters (3 bytes each). */
  107. typedef struct {
  108.     UBYTE red, green, blue;   /* MUST be UBYTEs so ">> 4" won't sign extend.*/
  109.     } ColorRegister;
  110.  
  111. /* ---------- Point2D --------------------------------------------------*/
  112. /* A Point2D is stored in a GRAB chunk. */
  113. typedef struct {
  114.     WORD x, y;      /* coordinates (pixels) */
  115.     } Point2D;
  116.  
  117. /* ---------- DestMerge ------------------------------------------------*/
  118. /* A DestMerge is stored in a DEST chunk. */
  119. typedef struct {
  120.     UBYTE depth;   /* # bitplanes in the original source */
  121.     UBYTE pad1;      /* UNUSED; for consistency store 0 here */
  122.     UWORD planePick;   /* how to scatter source bitplanes into destination */
  123.     UWORD planeOnOff;   /* default bitplane data for planePick */
  124.     UWORD planeMask;   /* selects which bitplanes to store into */
  125.     } DestMerge;
  126.  
  127. /* ---------- SpritePrecedence -----------------------------------------*/
  128. /* A SpritePrecedence is stored in a SPRT chunk. */
  129. typedef UWORD SpritePrecedence;
  130.  
  131. /* ---------- Camg Amiga Viewport Mode Display ID ----------------------*/
  132. /* The CAMG chunk is used to store the Amiga display mode in which
  133.  * an ILBM is meant to be displayed.  This is very important, especially
  134.  * for special display modes such as HAM and HALFBRITE where the
  135.  * pixels are interpreted differently.
  136.  * Under V37 and higher, store a 32-bit Amiga DisplayID (aka. ModeID)
  137.  * in the ULONG ViewModes CAMG variable (from GetVPModeID(viewport)).
  138.  * Pre-V37, instead store the 16-bit viewport->Modes.
  139.  * See the current IFF manual for information on screening for bad CAMG
  140.  * chunks when interpreting a CAMG as a 32-bit DisplayID or 16-bit ViewMode.
  141.  * The chunk's content is declared as a ULONG.
  142.  */
  143. typedef struct {
  144.    ULONG ViewModes;
  145.    } CamgChunk;
  146.  
  147. /* ---------- CRange cycling chunk -------------------------------------*/
  148. #define RNG_NORATE  36   /* Dpaint uses this rate to mean non-active */
  149. /* A CRange is store in a CRNG chunk. */
  150. typedef struct {
  151.     WORD  pad1;              /* reserved for future use; store 0 here */
  152.     WORD  rate;      /* 60/sec=16384, 30/sec=8192, 1/sec=16384/60=273 */
  153.     WORD  active;     /* bit0 set = active, bit 1 set = reverse */
  154.     UBYTE low, high;   /* lower and upper color registers selected */
  155.     } CRange;
  156.  
  157. /* ---------- Ccrt (Graphicraft) cycling chunk -------------------------*/
  158. /* A Ccrt is stored in a CCRT chunk. */
  159. typedef struct {
  160.    WORD  direction;  /* 0=don't cycle, 1=forward, -1=backwards */
  161.    UBYTE start;      /* range lower */
  162.    UBYTE end;        /* range upper */
  163.    LONG  seconds;    /* seconds between cycling */
  164.    LONG  microseconds; /* msecs between cycling */
  165.    WORD  pad;        /* future exp - store 0 here */
  166.    } CcrtChunk;
  167.  
  168. /* If you are writing all of your chunks by hand,
  169.  * you can use these macros for these simple chunks.
  170.  */
  171. #define putbmhd(iff, bmHdr)  \
  172.     PutCk(iff, ID_BMHD, sizeof(BitMapHeader), (BYTE *)bmHdr)
  173. #define putgrab(iff, point2D)  \
  174.     PutCk(iff, ID_GRAB, sizeof(Point2D), (BYTE *)point2D)
  175. #define putdest(iff, destMerge)  \
  176.     PutCk(iff, ID_DEST, sizeof(DestMerge), (BYTE *)destMerge)
  177. #define putsprt(iff, spritePrec)  \
  178.     PutCk(iff, ID_SPRT, sizeof(SpritePrecedence), (BYTE *)spritePrec)
  179. #define putcamg(iff, camg)  \
  180.     PutCk(iff, ID_CAMG, sizeof(CamgChunk),(BYTE *)camg)
  181. #define putcrng(iff, crng)  \
  182.     PutCk(iff, ID_CRNG, sizeof(CRange),(BYTE *)crng)
  183. #define putccrt(iff, ccrt)  \
  184.     PutCk(iff, ID_CCRT, sizeof(CcrtChunk),(BYTE *)ccrt)
  185.  
  186. #ifndef NO_PROTOS
  187. /* unpacker.c */
  188. BOOL unpackrow(BYTE **pSource, BYTE **pDest, WORD srcBytes0, WORD dstBytes0);
  189.  
  190. /* packer.c */
  191. LONG packrow(BYTE **pSource, BYTE **pDest, LONG rowSize);
  192.  
  193. /* ilbmr.c  ILBM reader routines */
  194. LONG loadbody(struct IFFHandle *iff, struct BitMap *bitmap,
  195.         BitMapHeader *bmhd);
  196. LONG loadbody2(struct IFFHandle *iff, struct BitMap *bitmap, 
  197.         BYTE *mask, BitMapHeader *bmhd, 
  198.         BYTE *buffer, ULONG bufsize);
  199. LONG loadcmap(struct IFFHandle *, WORD *colortable, USHORT *pNcolors);
  200. LONG getcolors(struct ILBMInfo *ilbm);
  201. void freecolors(struct ILBMInfo *ilbm);
  202. LONG alloccolortable(struct ILBMInfo *ilbm);
  203. ULONG getcamg(struct ILBMInfo *ilbm);
  204.  
  205. /* ilbmw.c  ILBM writer routines */
  206. long initbmhd(BitMapHeader *bmhd, struct BitMap *bitmap,
  207.               WORD masking, WORD compression, WORD transparentColor,
  208.               WORD width, WORD height, WORD pageWidth, WORD pageHeight,
  209.               ULONG modeid);
  210. long putcmap(struct IFFHandle *iff,APTR colortable,UWORD ncolors,UWORD bitspergun);
  211. long putbody(struct IFFHandle *iff, struct BitMap *bitmap,
  212.         BYTE *mask, BitMapHeader *bmHdr,
  213.         BYTE *buffer, LONG bufsize);
  214.  
  215. /* getdisplay.c (used to load a display) */
  216. LONG showilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  217. BOOL unshowilbm(struct ILBMInfo *ilbm);
  218. LONG createdisplay(struct ILBMInfo *);
  219. BOOL deletedisplay(struct ILBMInfo *);
  220. LONG getdisplay(struct ILBMInfo *);
  221. BOOL freedisplay(struct ILBMInfo *);
  222.  
  223. /* getbitmap.c (used if just loading brush or bitmap) */
  224. LONG createbrush(struct ILBMInfo *);
  225. void deletebrush(struct ILBMInfo *);
  226. LONG getbitmap(struct ILBMInfo *);
  227. void freebitmap(struct ILBMInfo *);
  228.  
  229. /* screen.c (opens 1.3 or 2.0 screen) */
  230. struct Screen *openidscreen(struct ILBMInfo *,SHORT,SHORT,SHORT,ULONG);
  231. struct Window *opendisplay(struct ILBMInfo *,SHORT,SHORT,SHORT,ULONG);
  232. ULONG  modefallback(ULONG, SHORT, SHORT, SHORT);
  233. void clipit(SHORT wide, SHORT high, struct Rectangle *spos,
  234.     struct Rectangle *dclip, struct Rectangle *txto,
  235.     struct Rectangle *stdo,struct Rectangle *maxo,
  236.     struct Rectangle * uclip);
  237. BOOL closedisplay(struct ILBMInfo *ilbm);
  238.  
  239. /* loadilbm.c */
  240. LONG loadbrush(struct ILBMInfo *ilbm, UBYTE *filename);
  241. void unloadbrush(struct ILBMInfo *ilbm);
  242.  
  243. LONG queryilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  244.  
  245. LONG loadilbm(struct ILBMInfo *ilbm, UBYTE *filename);
  246. void unloadilbm(struct ILBMInfo *ilbm);
  247.  
  248. /* saveilbm.c */
  249. LONG screensave(struct ILBMInfo *ilbm,
  250.             struct Screen *scr,
  251.             struct Chunk *chunklist1, struct Chunk *chunklist2,
  252.             UBYTE *filename);
  253.  
  254. LONG saveilbm(struct ILBMInfo *ilbm,
  255.         struct BitMap *bitmap, ULONG modeid,
  256.         WORD width, WORD height, WORD pagewidth, WORD pageheight,
  257.         APTR colortable, UWORD count, UWORD bitspergun,
  258.                 WORD masking, WORD transparentColor,
  259.         struct Chunk *chunklist1, struct Chunk *chunklist2,
  260.         UBYTE *filename);
  261.  
  262.  
  263. /* screendump.c (print screen or brush) */
  264. int screendump(struct Screen *scr,
  265.      UWORD srcx, UWORD srcy, UWORD srcw, UWORD srch,
  266.      LONG destcols, UWORD special);
  267.  
  268. /* bmprintc.c (write C source for ILBM) */
  269. void BMPrintCRep(struct BitMap *bm, FILE *fp, UBYTE *name, UBYTE *fmt);  
  270.  
  271. #endif /* NO_PROTOS */
  272.  
  273. #endif /* IFFP_ILBM_H */
  274.